package com.titaniume.java3;

import com.titaniume.java2.Employee;
import com.titaniume.java2.EmployeeData;
import org.junit.Test;

import java.util.Arrays;
import java.util.List;
import java.util.stream.IntStream;
import java.util.stream.Stream;

/**
 *@program: JavaSenior
 *@description:
 *
 *  1.stream关注的是对数据的运算 与cpu打交道
 *  集合关注的是数据得存储，与内存打交道
 *
 *  2.
 *    stream自己不会存储元素
 *    stream不会  改变源对象 ，他们会返回一个新的stream
 *    stream操作是延迟的。这意味着他们会等到需要结果的时候执行
 *
 *  3.stream执行流 程
 *      ①：实例化
 *      ②：一系列中间操作
 *      ③：终止操作
 *
 * 4.说明
 *   一个中间操作链，对数据源的数据进行处理
 *   一旦执行终止操作，就执行中间操作链，并产生结果。之后，不会在被使用
 *
 *
 *
 *@author: renfei.huang
 *@create: 2021-11-02 17:02
 */
public class StreamAPITest {


    //创建Stream方式一:通过集合
    @Test
    public void  test1(){

        List<Employee> employees = EmployeeData.getEmployees();
        //default Stream<E> stream(): 返回一个顺序流
        Stream<Employee> stream = employees.stream();

        //default Stream<E> parallelStream :返回一个并行流
        Stream<Employee> employeeStream = employees.parallelStream();

    }



    //创建Stream方式二:通过数组
    @Test
    public void  test2(){

        int [] arr = new int [] {2,3,4,5,6};
       // 调用Arrays类的 static <T> Stream stream(T [] array);返回一个流
        IntStream stream = Arrays.stream(arr);

        Employee employee1 = new Employee(1001,"tom");
        Employee employee2 = new Employee(1002,"jack");
        Employee [] employees = new Employee[]{employee1,employee2};
        Stream<Employee> stream1 = Arrays.stream(employees);

    }


    //创建Stream方式三:通过Stream的of()
    @Test
    public void  test3(){

        Stream<String> stream1 = Stream.of("aa", "2", "cc");

        Stream<Integer> stream2 = Stream.of(1, 3, 3, 4);
    }



    //创建Stream方式四： 无限流 （造数据）
    @Test
    public void  test4(){

        //迭代
        //public static<T> Stream<T> iterate(final T seed,final UnaryOperator<T> f)
        //遍历前10偶数
        Stream.iterate(0, t -> t + 2)
                .limit(10)
                .forEach(System.out::println);

        //生成
        //public static<T> Stream<T> generate(Supplier<T> s)
        Stream.generate(Math::random).limit(10).forEach(System.out::println);

    }







}
